home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Games / Xconq 7.1.0 / src / xconq-7.1.0 / x11 / xdesign.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-07  |  24.3 KB  |  894 lines  |  [TEXT/R*ch]
  1. /* Designer tools for the X11 interface to Xconq.
  2.    Copyright (C) 1992, 1993, 1994, 1995, 1996 Stanley T. Shebs.
  3.  
  4. Xconq is free software; you can redistribute it and/or modify
  5. it under the terms of the GNU General Public License as published by
  6. the Free Software Foundation; either version 2, or (at your option)
  7. any later version.  See the file COPYING.  */
  8.  
  9. #include "conq.h"
  10. #include "xconq.h"
  11.  
  12. #ifdef DESIGNERS
  13.  
  14. static void design_tool_callback PARAMS ((Widget w, XtPointer client_data,
  15.                       XtPointer call_data));
  16. static void design_terrain_callback PARAMS ((Widget w, XtPointer client_data,
  17.                          XtPointer call_data));
  18. static void design_bg_terrain_callback PARAMS ((Widget w,
  19.                         XtPointer client_data,
  20.                         XtPointer call_data));
  21. static void design_unit_callback PARAMS ((Widget w, XtPointer client_data,
  22.                       XtPointer call_data));
  23. static void design_unit_side_callback PARAMS ((Widget w, XtPointer client_data,
  24.                            XtPointer call_data));
  25. static void design_people_side_callback PARAMS ((Widget w,
  26.                          XtPointer client_data,
  27.                          XtPointer call_data));
  28. static void design_feature_callback PARAMS ((Widget w, XtPointer client_data,
  29.                          XtPointer call_data));
  30. static void design_new_feature_callback PARAMS ((Widget w,
  31.                          XtPointer client_data,
  32.                          XtPointer call_data));
  33. static void design_brush_callback PARAMS ((Widget w, XtPointer client_data,
  34.                        XtPointer call_data));
  35. static void design_quit_callback PARAMS ((Widget w, XtPointer client_data,
  36.                       XtPointer call_data));
  37.  
  38. static void set_design_tool PARAMS ((Side *side, int tool));
  39.  
  40. void
  41. popup_design(side)
  42. Side *side;
  43. {
  44.     if (!side->ui->design_shell)
  45.       create_design(side);
  46.     /* Force this to "looktool" always, not much value in remembering current
  47.        tool across popdowns and re-popups. */
  48.     set_design_tool(side, looktool);
  49.     XtPopup(side->ui->design_shell, XtGrabNone);
  50.     /* Expose event will cause window contents to be drawn now. */
  51. }
  52.  
  53. void
  54. create_design(side)
  55. Side *side;
  56. {
  57.     int designw, designh, paneh;
  58.     Widget pane, label, button;
  59.     Display *dpy = side->ui->dpy;
  60.  
  61.     paneh = 50;
  62.     designw = 200;  designh = 6 * paneh;
  63.     side->ui->design_shell =
  64.       XtVaCreatePopupShell("Design", topLevelShellWidgetClass, side->ui->shell,
  65.                XtNwidth, designw,
  66.                XtNheight, designh,
  67.                NULL);
  68.     side->ui->design =
  69.       XtVaCreateManagedWidget("Design", panedWidgetClass, side->ui->design_shell,
  70.                   XtNwidth, designw,
  71.                   XtNheight, designh,
  72.                   NULL);
  73.  
  74.     pane =
  75.       XtVaCreateManagedWidget("NormalPane", boxWidgetClass, side->ui->design,
  76.                   XtNwidth, designw,
  77.                   XtNheight, paneh,
  78.                   XtNmax, paneh,
  79.                   XtNmin, paneh,
  80.                   XtNshowGrip, False,
  81.                   XtNskipAdjust, True,
  82.                   NULL);
  83.     side->ui->normal_button =
  84.       XtVaCreateManagedWidget("Normal", toggleWidgetClass, pane,
  85.                   XtNlabel, "Norm",
  86.                   NULL);
  87.     XtAddCallback(side->ui->normal_button, XtNcallback,
  88.           design_tool_callback, (XtPointer) looktool);
  89.     side->ui->normal_label =
  90.       XtVaCreateManagedWidget("NormalLabel", labelWidgetClass, pane,
  91.                   XtNborderWidth, 0,
  92.                   XtNjustify, XtJustifyLeft,
  93.                   XtNlabel, " ",
  94.                   XtNresize, False,
  95.                   XtNwidth, 150,
  96.                   NULL);
  97.     button =
  98.       XtVaCreateManagedWidget("Quit", commandWidgetClass, pane,
  99.                   XtNlabel, "Quit",
  100.                   NULL);
  101.     XtAddCallback(button, XtNcallback,
  102.           design_quit_callback, NULL);
  103.  
  104.  
  105.     pane =
  106.       XtVaCreateManagedWidget("TerrainPane", boxWidgetClass, side->ui->design,
  107.                   XtNwidth, designw,
  108.                   XtNheight, paneh,
  109.                   XtNmax, paneh,
  110.                   XtNmin, paneh,
  111.                   XtNshowGrip, False,
  112.                   XtNskipAdjust, True,
  113.                   NULL);
  114.     side->ui->terrain_button =
  115.       XtVaCreateManagedWidget("Terrain", toggleWidgetClass, pane,
  116.                   XtNlabel, "Terr",
  117.                   NULL);
  118.     XtAddCallback(side->ui->terrain_button, XtNcallback,
  119.           design_tool_callback, (XtPointer) cellpainttool);
  120.     side->ui->terrain_label =
  121.       XtVaCreateManagedWidget("Terrain", labelWidgetClass, pane,
  122.                   XtNborderWidth, 0,
  123.                   XtNjustify, XtJustifyLeft,
  124.                   XtNresize, False,
  125.                   XtNwidth, 150,
  126.                   NULL);
  127.     button =
  128.       XtVaCreateManagedWidget("fgTerrMinus", commandWidgetClass, pane,
  129.                   XtNlabel, "fg-",
  130.                   NULL);
  131.     XtAddCallback(button, XtNcallback,
  132.           design_terrain_callback, (XtPointer) (-1));
  133.     button =
  134.       XtVaCreateManagedWidget("fgTerrPlus", commandWidgetClass, pane,
  135.                   XtNlabel, "fg+",
  136.                   NULL);
  137.     XtAddCallback(button, XtNcallback,
  138.           design_terrain_callback, (XtPointer) (1));
  139.     button =
  140.       XtVaCreateManagedWidget("bgTerrMinus", commandWidgetClass, pane,
  141.                   XtNlabel, "bg-",
  142.                   NULL);
  143.     XtAddCallback(button, XtNcallback,
  144.           design_bg_terrain_callback, (XtPointer) (-1));
  145.     button =
  146.       XtVaCreateManagedWidget("bgTerrPlus", commandWidgetClass, pane,
  147.                   XtNlabel, "bg+",
  148.                   NULL);
  149.     XtAddCallback(button, XtNcallback,
  150.           design_bg_terrain_callback, (XtPointer) (1));
  151.     update_curttype(side);
  152.  
  153.     pane =
  154.       XtVaCreateManagedWidget("UnitPane", boxWidgetClass, side->ui->design,
  155.                   XtNwidth, designw,
  156.                   XtNheight, paneh,
  157.                   XtNmax, paneh,
  158.                   XtNmin, paneh,
  159.                   XtNshowGrip, False,
  160.                   XtNskipAdjust, True,
  161.                   NULL);
  162.     side->ui->unit_button =
  163.       XtVaCreateManagedWidget("Unit", toggleWidgetClass, pane,
  164.                   XtNlabel, "Unit",
  165.                   NULL);
  166.     XtAddCallback(side->ui->unit_button, XtNcallback,
  167.           design_tool_callback, (XtPointer) unitaddtool);
  168.     side->ui->unit_label =
  169.       XtVaCreateManagedWidget("UnitLabel", labelWidgetClass, pane,
  170.                   XtNborderWidth, 0,
  171.                   XtNjustify, XtJustifyLeft,
  172.                   XtNresize, False,
  173.                   XtNwidth, 150,
  174.                   NULL);
  175.     button =
  176.       XtVaCreateManagedWidget("unitMinus", commandWidgetClass, pane,
  177.                   XtNlabel, "u-",
  178.                   NULL);
  179.     XtAddCallback(button, XtNcallback,
  180.           design_unit_callback, (XtPointer) (-1));
  181.     button =
  182.       XtVaCreateManagedWidget("unitPlus", commandWidgetClass, pane,
  183.                   XtNlabel, "u+",
  184.                   NULL);
  185.     XtAddCallback(button, XtNcallback,
  186.           design_unit_callback, (XtPointer) (1));
  187.     button =
  188.       XtVaCreateManagedWidget("unitSideMinus", commandWidgetClass, pane,
  189.                   XtNlabel, "s-",
  190.                   NULL);
  191.     XtAddCallback(button, XtNcallback,
  192.           design_unit_side_callback, (XtPointer) (-1));
  193.     button =
  194.       XtVaCreateManagedWidget("unitSidePlus", commandWidgetClass, pane,
  195.                   XtNlabel, "s+",
  196.                   NULL);
  197.     XtAddCallback(button, XtNcallback,
  198.           design_unit_side_callback, (XtPointer) (1));
  199.     update_curutype(side);
  200.  
  201.     pane =
  202.       XtVaCreateManagedWidget("PeoplePane", boxWidgetClass, side->ui->design,
  203.                   XtNwidth, designw,
  204.                   XtNheight, paneh,
  205.                   XtNmax, paneh,
  206.                   XtNmin, paneh,
  207.                   XtNshowGrip, False,
  208.                   XtNskipAdjust, True,
  209.                   NULL);
  210.     side->ui->people_button =
  211.       XtVaCreateManagedWidget("People", toggleWidgetClass, pane,
  212.                   XtNlabel, "Peop",
  213.                   NULL);
  214.     XtAddCallback(side->ui->people_button, XtNcallback,
  215.           design_tool_callback, (XtPointer) peoplepainttool);
  216.     side->ui->people_label =
  217.       XtVaCreateManagedWidget("PeopleLabel", labelWidgetClass, pane,
  218.                   XtNborderWidth, 0,
  219.                   XtNjustify, XtJustifyLeft,
  220.                   XtNresize, False,
  221.                   XtNwidth, 150,
  222.                   NULL);
  223.     button =
  224.       XtVaCreateManagedWidget("peopleMinus", commandWidgetClass, pane,
  225.                   XtNlabel, "p-",
  226.                   NULL);
  227.     XtAddCallback(button, XtNcallback,
  228.           design_people_side_callback, (XtPointer) (-1));
  229.     button =
  230.       XtVaCreateManagedWidget("peoplePlus", commandWidgetClass, pane,
  231.                   XtNlabel, "p+",
  232.                   NULL);
  233.     XtAddCallback(button, XtNcallback,
  234.           design_people_side_callback, (XtPointer) (1));
  235.     update_cursidenumber(side);
  236.  
  237.     pane =
  238.       XtVaCreateManagedWidget("FeaturePane", boxWidgetClass, side->ui->design,
  239.                   XtNwidth, designw,
  240.                   XtNheight, paneh,
  241.                   XtNmax, paneh,
  242.                   XtNmin, paneh,
  243.                   XtNshowGrip, False,
  244.                   XtNskipAdjust, True,
  245.                   NULL);
  246.     side->ui->feature_button =
  247.       XtVaCreateManagedWidget("Feature", toggleWidgetClass, pane,
  248.                   XtNlabel, "Feat",
  249.                   NULL);
  250.     XtAddCallback(side->ui->feature_button, XtNcallback,
  251.           design_tool_callback, (XtPointer) featurepainttool);
  252.     side->ui->feature_label =
  253.       XtVaCreateManagedWidget("FeatureLabel", labelWidgetClass, pane,
  254.                   XtNborderWidth, 0,
  255.                   XtNjustify, XtJustifyLeft,
  256.                   XtNresize, False,
  257.                   XtNwidth, 150,
  258.                   NULL);
  259.     button =
  260.       XtVaCreateManagedWidget("featureMinus", commandWidgetClass, pane,
  261.                   XtNlabel, "f-",
  262.                   NULL);
  263.     XtAddCallback(button, XtNcallback,
  264.           design_feature_callback, (XtPointer) (-1));
  265.     button =
  266.       XtVaCreateManagedWidget("featurePlus", commandWidgetClass, pane,
  267.                   XtNlabel, "f+",
  268.                   NULL);
  269.     XtAddCallback(button, XtNcallback,
  270.           design_feature_callback, (XtPointer) (1));
  271.     button =
  272.       XtVaCreateManagedWidget("newFeature", commandWidgetClass, pane,
  273.                   XtNlabel, "new",
  274.                   NULL);
  275.     XtAddCallback(button, XtNcallback,
  276.           design_new_feature_callback, NULL);
  277.     update_curfeature(side);
  278.  
  279.     pane =
  280.       XtVaCreateManagedWidget("BrushPane", boxWidgetClass, side->ui->design,
  281.                   XtNwidth, designw,
  282.                   XtNheight, paneh,
  283.                   XtNmax, paneh,
  284.                   XtNmin, paneh,
  285.                   XtNshowGrip, False,
  286.                   XtNskipAdjust, True,
  287.                   NULL);
  288.     label =
  289.       XtVaCreateManagedWidget("brushRadius", labelWidgetClass, pane,
  290.                   XtNborderWidth, 0,
  291.                   XtNlabel, "  ",
  292.                   NULL);
  293.     side->ui->brush_radius_label =
  294.       XtVaCreateManagedWidget("brushRadiusLabel", labelWidgetClass, pane,
  295.                   XtNborderWidth, 0,
  296.                   XtNresize, False,
  297.                   XtNwidth, 150,
  298.                   NULL);
  299.     button =
  300.       XtVaCreateManagedWidget("brushMinus", commandWidgetClass, pane,
  301.                   XtNlabel, "-",
  302.                   NULL);
  303.     XtAddCallback(button, XtNcallback,
  304.           design_brush_callback, (XtPointer) (-1));
  305.     button =
  306.       XtVaCreateManagedWidget("brushPlus", commandWidgetClass, pane,
  307.                   XtNlabel, "+",
  308.                   NULL);
  309.     XtAddCallback(button, XtNcallback,
  310.           design_brush_callback, (XtPointer) (1));
  311.     button =
  312.       XtVaCreateManagedWidget("brushReset", commandWidgetClass, pane,
  313.                   XtNlabel, "0",
  314.                   NULL);
  315.     XtAddCallback(button, XtNcallback,
  316.           design_brush_callback, (XtPointer) (0));
  317.     update_curbrushradius(side);
  318.  
  319.     /* (should add other tools here) */
  320.  
  321.     XtRealizeWidget(side->ui->design_shell);
  322.  
  323.     /* XtWindow works only after a call to XtRealizeWidget. */
  324.     XSetWMProtocols(dpy, XtWindow(side->ui->design_shell),
  325.             &side->ui->kill_atom, 1);
  326.     XtOverrideTranslations(side->ui->design_shell,
  327.     XtParseTranslationTable("<Message>WM_PROTOCOLS: wm-quit()"));
  328.  
  329. }
  330.  
  331. static void
  332. design_tool_callback(w, client_data, call_data)
  333. Widget w;
  334. XtPointer client_data;
  335. XtPointer call_data;
  336. {
  337.     int which = (int) client_data;
  338.     Side *side;
  339.     Map *map;
  340.  
  341.     if (find_side_via_widget(w, &side)) {
  342.         set_design_tool(side, which);
  343.         for_all_maps(side, map) {
  344.         update_controls(side, map);
  345.         set_tool_cursor(side, map);
  346.     }
  347.     }
  348. }
  349.  
  350. static void
  351. set_design_tool(side, tool)
  352. Side *side;
  353. int tool;
  354. {
  355.     Map *map;
  356.  
  357.     side->ui->curdesigntool = tool;
  358.     nargs = 0;
  359.     XtSetArg(tmpargs[nargs], XtNstate, (Boolean) (tool == looktool));  nargs++;
  360.     XtSetValues (side->ui->normal_button, tmpargs, nargs);
  361.     nargs = 0;
  362.     XtSetArg(tmpargs[nargs], XtNstate, (Boolean) (tool == cellpainttool));  nargs++;
  363.     XtSetValues (side->ui->terrain_button, tmpargs, nargs);
  364.     nargs = 0;
  365.     XtSetArg(tmpargs[nargs], XtNstate, (Boolean) (tool == unitaddtool));  nargs++;
  366.     XtSetValues (side->ui->unit_button, tmpargs, nargs);
  367.     nargs = 0;
  368.     XtSetArg(tmpargs[nargs], XtNstate, (Boolean) (tool == peoplepainttool));  nargs++;
  369.     XtSetValues (side->ui->people_button, tmpargs, nargs);
  370.     nargs = 0;
  371.     XtSetArg(tmpargs[nargs], XtNstate, (Boolean) (tool == featurepainttool));  nargs++;
  372.     XtSetValues (side->ui->feature_button, tmpargs, nargs);
  373.     /* As a special case, set the actual terrain tool based on terrain
  374.        subtype. */
  375.     if (tool == cellpainttool && t_is_border(side->ui->curttype))
  376.       side->ui->curdesigntool = bordpainttool;
  377.     if (tool == cellpainttool && t_is_connection(side->ui->curttype))
  378.       side->ui->curdesigntool = connpainttool;
  379.     for_all_maps(side, map) {
  380.     map->curtool = side->ui->curdesigntool;
  381.     }
  382. }
  383.  
  384. /* This macro implements cycling of a variable through a set of
  385.    consecutive values, with given dir.  If the limit is 0, then the
  386.    cycling part is not done. */
  387.  
  388. #define OPTION_CYCLE(var, lo, hi, which)  \
  389.   if ((hi) - (lo) > 0) {  \
  390.     (var) = (((var) + (which) - (lo) + ((hi) - (lo))) % ((hi) - (lo))) + (lo);  \
  391.   } else {  \
  392.     (var) = ((var) + (which));  \
  393.   }
  394.  
  395. static void
  396. design_terrain_callback(w, client_data, call_data)
  397. Widget w;
  398. XtPointer client_data;
  399. XtPointer call_data;
  400. {
  401.     int which = (int) client_data;
  402.     Side *side;
  403.     Map *map;
  404.  
  405.     if (!find_side_via_widget(w, &side))
  406.       return;
  407.  
  408.     OPTION_CYCLE(side->ui->curttype, 0, numttypes, which);
  409.     update_curttype(side);
  410.     /* Do this also, because the terrain type change might necessitate
  411.        a tool cursor change.  If the type should not be
  412.        "cellpainttool", this will change it to the appropriate one. */
  413.     set_design_tool(side, cellpainttool);
  414.     for_all_maps(side, map) {
  415.     update_controls(side, map);
  416.     set_tool_cursor(side, map);
  417.     }
  418. }
  419.  
  420. static void
  421. design_bg_terrain_callback(w, client_data, call_data)
  422. Widget w;
  423. XtPointer client_data;
  424. XtPointer call_data;
  425. {
  426.     int which = (int) client_data;
  427.     Side *side;
  428.     Map *map;
  429.  
  430.     if (!find_side_via_widget(w, &side))
  431.       return;
  432.  
  433.     /* (should only cycle through allowed types?) */
  434.     side->ui->curbgttype =
  435.       (side->ui->curbgttype + which + numttypes) % numttypes;
  436.     update_curttype(side);
  437.     set_design_tool(side, cellpainttool);
  438.     for_all_maps(side, map) {
  439.     update_controls(side, map);
  440.     set_tool_cursor(side, map);
  441.     }
  442. }
  443.  
  444. static void
  445. design_unit_callback(w, client_data, call_data)
  446. Widget w;
  447. XtPointer client_data;
  448. XtPointer call_data;
  449. {
  450.     int which = (int) client_data;
  451.     Side *side;
  452.  
  453.     if (!find_side_via_widget(w, &side))
  454.       return;
  455.  
  456.     /* (should only cycle through allowed types?) */
  457.     side->ui->curutype = (side->ui->curutype + which + numutypes) % numutypes;
  458.     update_curutype(side);
  459. }
  460.  
  461. static void
  462. design_unit_side_callback(w, client_data, call_data)
  463. Widget w;
  464. XtPointer client_data;
  465. XtPointer call_data;
  466. {
  467.     int which = (int) client_data;
  468.     Side *side;
  469.  
  470.     if (!find_side_via_widget(w, &side))
  471.       return;
  472.  
  473.     /* (should only cycle through allowed types?) */
  474.     side->ui->curusidenumber =
  475.       (side->ui->curusidenumber + which + (numsides + 1)) % (numsides + 1);
  476.     update_curutype(side);
  477. }
  478.  
  479. static void
  480. design_people_side_callback(w, client_data, call_data)
  481. Widget w;
  482. XtPointer client_data;
  483. XtPointer call_data;
  484. {
  485.     int which = (int) client_data;
  486.     Side *side;
  487.  
  488.     if (!find_side_via_widget(w, &side))
  489.       return;
  490.  
  491.     side->ui->cursidenumber =
  492.       (side->ui->cursidenumber + which + (numsides + 1)) % (numsides + 1);
  493.     update_cursidenumber(side);
  494. }
  495.  
  496. static void
  497. design_feature_callback(w, client_data, call_data)
  498. Widget w;
  499. XtPointer client_data;
  500. XtPointer call_data;
  501. {
  502.     int which = (int) client_data;
  503.     Side *side;
  504.     extern int nextfid;
  505.  
  506.     if (!find_side_via_widget(w, &side))
  507.       return;
  508.  
  509.     if (!features_defined())
  510.       return;
  511.  
  512.     OPTION_CYCLE(side->ui->curfid, 0, nextfid, which);
  513.     update_curfeature(side);
  514. }
  515.  
  516. static void
  517. design_new_feature_callback(w, client_data, call_data)
  518. Widget w;
  519. XtPointer client_data;
  520. XtPointer call_data;
  521. {
  522.     Feature *feature;
  523.     Side *side;
  524.     extern int nextfid;
  525.  
  526.     if (!find_side_via_widget(w, &side))
  527.       return;
  528.  
  529.     sprintf(spbuf, "%d", nextfid);
  530.     feature = create_feature("feature", copy_string(spbuf));
  531.     if (feature != NULL) {
  532.     side->ui->curfid = feature->id;
  533.     }
  534.     update_curfeature(side);
  535. }
  536.  
  537. static void
  538. design_brush_callback(w, client_data, call_data)
  539. Widget w;
  540. XtPointer client_data;
  541. XtPointer call_data;
  542. {
  543.     int which = (int) client_data;
  544.     Side *side;
  545.  
  546.     if (!find_side_via_widget(w, &side))
  547.       return;
  548.  
  549.     switch (which) {
  550.       case -1:
  551.     if (side->ui->curbrushradius > 0)
  552.       --(side->ui->curbrushradius);
  553.     break;
  554.       case 0:
  555.     side->ui->curbrushradius = 0;
  556.     break;
  557.       case 1:
  558.     ++(side->ui->curbrushradius);
  559.     break;
  560.       default:
  561.     run_error("huh??");
  562.     break;
  563.     }
  564.     update_curbrushradius(side);
  565. }
  566.  
  567. static void
  568. design_quit_callback(w, client_data, call_data)
  569. Widget w;
  570. XtPointer client_data;
  571. XtPointer call_data;
  572. {
  573.     Side *side;
  574.     Map *map;
  575.  
  576.     if (!find_side_via_widget(w, &side))
  577.       return;
  578.  
  579.     popdown_design(side);
  580.     become_nondesigner(side);
  581.     for_all_maps(side, map) {
  582.     map->curtool = looktool;
  583.     set_tool_cursor(side, map);
  584.     update_controls(side, map);
  585.     }
  586. }
  587.  
  588. void
  589. update_curttype(side)
  590. Side *side;
  591. {
  592.     char buf[BUFSIZE];
  593. #if 0
  594.     Control *control = &(map->controlbs[CURTTYPE]);
  595.     Image *timg = best_image(side->ui->timages[side->ui->curttype], 16, 16);
  596.     X11Image *ximg = timg ? (X11Image *) timg->hook : NULL;
  597.     GC gc = side->ui->textgc;
  598.     Display *dpy = side->ui->dpy;
  599.     int x=0, y=0, w=16, h=16;
  600. #endif
  601.  
  602.     switch (t_subtype(side->ui->curttype)) {
  603.       case cellsubtype:
  604.     sprintf(buf, "%s/%s",
  605.         t_type_name(side->ui->curttype),
  606.         t_type_name(side->ui->curbgttype));
  607.     break;
  608.       case bordersubtype:
  609.     sprintf(buf, "%s (bord)", t_type_name(side->ui->curttype));
  610.     break;
  611.       case connectionsubtype:
  612.     sprintf(buf, "%s (conn)", t_type_name(side->ui->curttype));
  613.     break;
  614.       case coatingsubtype:
  615.     sprintf(buf, "%s (coat)", t_type_name(side->ui->curttype));
  616.     break;
  617.       default:
  618.     terrain_subtype_warning("ttype update", side->ui->curttype);
  619.     break;
  620.     }
  621. #if 0
  622.     if (t_subtype(side->ui->curttype) == connectionsubtype) {
  623.     /* draw a horizontal line */
  624.     y = 5;
  625.     h = 5;
  626.     } else if (t_subtype(side->ui->curttype) == bordersubtype) {
  627.     /* draw a vertical line */
  628.     x = 5;
  629.     w = 5;
  630.     }
  631.  
  632.     /* clear the pixmap */
  633.     XSetForeground(dpy, gc, side->ui->bgcolor);
  634.     XFillRectangle(dpy, control->pic, gc, 0, 0, 16, 16);
  635.  
  636.     control->color = side->ui->cellcolor[side->ui->curttype];
  637.     XSetForeground(dpy, gc, control->color);
  638.  
  639.     /* XSetTSOrigin coordinates are tweaked to get roads "right" */
  640.     if (side->ui->monochrome && ximg && ximg->mono != None) {
  641.     XSetFillStyle(dpy, gc, FillStippled);
  642.     XSetStipple(dpy, gc, ximg->mono);
  643.     XSetTSOrigin(dpy, gc, 2, 2);
  644.     } else if (!side->ui->monochrome && side->ui->usecolorimages && ximg && ximg->colr != None) {
  645.     XSetFillStyle(dpy, gc, FillTiled);
  646.     XSetTile(dpy, gc, ximg->colr);
  647.     XSetTSOrigin(dpy, gc, 2, 2);
  648.     }
  649.     XFillRectangle(dpy, control->pic, gc, x, y, w, h);
  650.     XtVaSetValues(control->control, XtNbitmap, control->pic, NULL); 
  651.  
  652.     XSetFillStyle(dpy, gc, FillSolid);
  653. #endif
  654.  
  655.     nargs = 0;
  656.     XtSetArg(tmpargs[nargs], XtNlabel, buf);  nargs++;
  657. #if 0 
  658.     XtSetArg(tmpargs[nargs], XtNleftBitmap, pic);  nargs++;
  659. #endif
  660.     XtSetValues(side->ui->terrain_label, tmpargs, nargs);
  661. }
  662.  
  663. void
  664. update_curutype(side)
  665. Side *side;
  666. {
  667.     char buf[BUFSIZE];
  668.  
  669.     sprintf(buf, "%s (%s)",
  670.          u_type_name(side->ui->curutype),
  671.          side_adjective(side_n(side->ui->curusidenumber)));
  672.  
  673. #if 0  /* (should include side emblem also) */
  674.     XSetFillStyle(side->ui->dpy, side->ui->unitgc, FillSolid);
  675.     XSetForeground(side->ui->dpy, side->ui->unitgc, side->ui->bgcolor);
  676.     XFillRectangle(side->ui->dpy, side->ui->unitbuttonpic,
  677.            side->ui->unitgc, 0, 0, 32, 32);
  678.     draw_unit_image(side, side->ui->unitbuttonpic, 0, 0, 16, 16,
  679.             side->ui->curutype, -1,
  680.             side->ui->fgcolor, side->ui->bgcolor);
  681. #endif
  682.  
  683.     nargs = 0;
  684.     XtSetArg(tmpargs[nargs], XtNlabel, buf);  nargs++;
  685. #if 0
  686.     XtSetArg(tmpargs[nargs], XtNleftBitmap, side->ui->unitbuttonpic);  nargs++;
  687. #endif
  688.     XtSetValues(side->ui->unit_label, tmpargs, nargs);
  689. }
  690.  
  691. void
  692. update_cursidenumber(side)
  693. Side *side;
  694. {
  695.     char buf[BUFSIZE];
  696.  
  697.     sprintf(buf, "%s (%d)",
  698.         side_adjective(side_n(side->ui->cursidenumber)),
  699.         side->ui->cursidenumber);
  700.     XtVaSetValues(side->ui->people_label, XtNlabel, buf, NULL);
  701. }
  702.  
  703. void
  704. update_curfeature(side)
  705. Side *side;
  706. {
  707.     char buf[BUFSIZE], *rslt;
  708.     Feature *feature;
  709.  
  710.     feature = find_feature(side->ui->curfid);
  711.     rslt = feature_desc(feature, buf);
  712.     if (rslt == NULL) {
  713.     if (side->ui->curfid > 0) {
  714.         sprintf(buf, "??? (%d)", side->ui->curfid);
  715.         rslt = buf;
  716.         } else
  717.       rslt = "no feature";
  718.     }
  719.     XtVaSetValues(side->ui->feature_label, XtNlabel, rslt, NULL);
  720. }
  721.  
  722. void
  723. update_curbrushradius(side)
  724. Side *side;
  725. {
  726.     char buf[BUFSIZE];
  727.  
  728.     sprintf(buf, "brush radius = %d", side->ui->curbrushradius);
  729.     XtVaSetValues(side->ui->brush_radius_label, XtNlabel, buf, NULL);
  730. }
  731.  
  732. /* Given a location in a map, pick up whatever is there and make
  733.    it the current terrain/unit/whatever, according to the design tool
  734.    currently in use. */
  735.  
  736. void
  737. set_designer_cur_from_map(side, map, sx, sy)
  738. Side *side;
  739. Map *map;
  740. int sx, sy;
  741. {
  742.     int x, y;
  743.     Unit *unit;
  744.  
  745.     if (!side->designer)
  746.       return;
  747.     if (!x_nearest_cell(side, map, sx, sy, &x, &y)) {
  748.     beep(side);
  749.     return;
  750.     }
  751.     switch (map->curtool) {
  752.       case cellpainttool:
  753.     side->ui->curttype = terrain_at(x, y);
  754.     update_curttype(side);
  755.     /* Do this also, because the terrain type change might necessitate
  756.        a tool cursor change.  If the type should not be
  757.        "cellpainttool", this will change it to the appropriate one. */
  758.     set_design_tool(side, cellpainttool);
  759.     break;
  760.       case bordpainttool:
  761.     /* (should make this work) */
  762.     beep(side);
  763.     break;
  764.       case connpainttool:
  765.     /* (should make this work) */
  766.     beep(side);
  767.     break;
  768.       case unitaddtool:
  769.     /* (should be unit exactly under sx,sy) */
  770.         unit = unit_at(x, y);
  771.     if (unit) {
  772.         side->ui->curutype = unit->type;
  773.         update_curutype(side);
  774.     } else {
  775.         beep(side);
  776.     }
  777.     break;
  778.       case peoplepainttool:
  779.     if (people_sides_defined()) {
  780.         side->ui->cursidenumber = people_side_at(x, y);
  781.         update_cursidenumber(side);
  782.     } else {
  783.         beep(side);
  784.     }
  785.     break;
  786.       case featurepainttool:
  787.     if (features_defined()) {
  788.         side->ui->curfid = raw_feature_at(x, y);
  789.         update_curfeature(side);
  790.     } else {
  791.         beep(side);
  792.     }
  793.     break;
  794.       default:
  795.     /* error eventually */
  796.     break;
  797.     }
  798. }
  799.  
  800. void
  801. handle_designer_map_click(side, map, sx, sy)
  802. Side *side;
  803. Map *map;
  804. int sx, sy;
  805. {
  806.     int ax, ay, bx, by, dir, x, y;
  807.     int oldt, painttype;
  808.     int oldpeop, paintpeop;
  809.     int oldfid, paintfid;
  810.     Unit *unit;
  811.  
  812.     if (!x_nearest_cell(side, map, sx, sy, &ax, &ay)) {
  813.     beep(side);
  814.     return;
  815.     }
  816.     switch (map->curtool) {
  817.       case cellpainttool:
  818.       case bordpainttool:
  819.       case connpainttool:
  820.     x = ax;  y = ay;
  821.     switch (t_subtype(side->ui->curttype)) {
  822.       case cellsubtype:
  823.         /* Choose to paint fg or bg type, depending on what's already
  824.            there. */
  825.         oldt = terrain_at(x, y);
  826.         painttype = (side->ui->curttype == oldt ? side->ui->curbgttype :
  827.              side->ui->curttype);
  828.         paint_cell(side, x, y, side->ui->curbrushradius, painttype);
  829.         break;
  830.       case bordersubtype:
  831.         if (!x_nearest_boundary(side, map, sx, sy, &bx, &by, &dir)) {
  832.         beep(side);
  833.         return;
  834.         }
  835.         if (inside_area(bx, by)) {
  836.         painttype = side->ui->curttype;
  837.         paint_border(side, bx, by, dir, painttype, -1);
  838.         }
  839.         break;
  840.       case connectionsubtype:
  841.         if (!x_nearest_boundary(side, map, sx, sy, &bx, &by, &dir)) {
  842.         beep(side);
  843.         return;
  844.         }
  845.         if (inside_area(bx, by)) {
  846.         painttype = side->ui->curttype;
  847.         paint_connection(side, bx, by, dir, painttype, -1);
  848.         }
  849.         break;
  850.       case coatingsubtype:
  851.         break;
  852.       default:
  853.         case_panic("terrain subtype", t_subtype(side->ui->curttype));
  854.         break;
  855.         }
  856.     break;
  857.       case unitaddtool:
  858.     unit = designer_create_unit(side, side->ui->curutype,
  859.                     side->ui->cursidenumber, ax, ay);
  860.     if (unit != NULL) {
  861.         /* (should make it be current) */
  862.     } else {
  863.         /* Something's wrong. */
  864.         beep(side);
  865.     }
  866.     break;
  867.       case peoplepainttool:
  868.         oldpeop = people_side_at(ax, ay);
  869.         paintpeop =
  870.           (side->ui->cursidenumber == oldpeop ? NOBODY : side->ui->cursidenumber);
  871.         paint_people(side, ax, ay, side->ui->curbrushradius, paintpeop);
  872.     break;
  873.       case featurepainttool:
  874.     oldfid = raw_feature_at(ax, ay);
  875.     paintfid = (side->ui->curfid == oldfid ? 0 : side->ui->curfid);
  876.     paint_feature(side, ax, ay, side->ui->curbrushradius, paintfid);
  877.     break;
  878.       default:
  879.     /* complain or ignore? */
  880.     break;
  881.     }
  882. }
  883.  
  884. void
  885. popdown_design(side)
  886. Side *side;
  887. {
  888.     if (side->ui->design_shell)
  889.       XtPopdown(side->ui->design_shell);
  890. }
  891.  
  892. #endif /* DESIGNERS */
  893.  
  894.